Current file: C:\wamp\www\Smarty3.2\lib\Smarty\Compiler\Template\Compiler.php
Legend: executed not executed dead code

  Coverage
  Classes Functions / Methods Lines
Total
0.00%0.00%
0.00% 0 / 1
41.67%41.67%
41.67% 5 / 12 CRAP
83.53%83.53%
83.53% 355 / 425
 
Smarty_Compiler_Template_Compiler
0.00%0.00%
0.00% 0 / 1
50.00%50.00%
50.00% 1 / 2
89.66%89.66%
89.66% 26 / 29
 __construct($lexer_class, $parser_class, $tpl_obj, $source, $caching)
100.00%100.00%
100.00% 1 / 1 1
100.00%100.00%
100.00% 8 / 8
 doCompile($_content = null)
0.00%0.00%
0.00% 0 / 1 5.26
57.14%57.14%
57.14% 4 / 7
Functions
  
   
40.00%40.00%
40.00% 4 / 10
100.00%100.00%
100.00% 0 / 0
 compileTemplateSource(Smarty_Compiled_Resource $compiled)
0.00%0.00%
0.00% 0 / 1 16.24
82.35%82.35%
82.35% 28 / 34
 compileTemplate()
100.00%100.00%
100.00% 1 / 1 8
100.00%100.00%
100.00% 28 / 28
 compileTag($tag, $args, $parameter = array()
0.00%0.00%
0.00% 0 / 1 99.56
75.00%75.00%
75.00% 72 / 96
 compileCoreTag($tag, $args, $param1 = null, $param2 = null, $param3 = null)
0.00%0.00%
0.00% 0 / 1 6.02
92.31%92.31%
92.31% 12 / 13
 compileVariable($variable)
100.00%100.00%
100.00% 1 / 1 2
100.00%100.00%
100.00% 6 / 6
 getPlugin($plugin_name, $plugin_type)
0.00%0.00%
0.00% 0 / 1 18.81
77.78%77.78%
77.78% 28 / 36
 getPluginFromDefaultHandler($tag, $plugin_type)
0.00%0.00%
0.00% 0 / 1 8
95.00%95.00%
95.00% 19 / 20
 nocacheCode($tagCode, $is_code)
0.00%0.00%
0.00% 0 / 1 21.35
85.00%85.00%
85.00% 34 / 40
 trigger_template_error($msg = null, $line = null)
100.00%100.00%
100.00% 1 / 1 5
100.00%100.00%
100.00% 21 / 21
 _createSmartyContentClass(Smarty $tpl_obj, $noinstance = false)
100.00%100.00%
100.00% 1 / 1 1
100.00%100.00%
100.00% 2 / 2


       1                 : <?php                                                                                                                                                                                                                                  
       2                 :                                                                                                                                                                                                                                        
       3                 : /**                                                                                                                                                                                                                                    
       4                 :  * Smarty Internal Plugin Smarty Template Compiler Base                                                                                                                                                                                
       5                 :  *                                                                                                                                                                                                                                     
       6                 :  * This file contains the basic classes and methods for compiling Smarty templates with lexer/parser                                                                                                                                   
       7                 :  *                                                                                                                                                                                                                                     
       8                 :  *                                                                                                                                                                                                                                     
       9                 :  * @package Compiler                                                                                                                                                                                                                   
      10                 :  * @author Uwe Tews                                                                                                                                                                                                                    
      11                 :  */                                                                                                                                                                                                                                    
      12                 :                                                                                                                                                                                                                                        
      13                 : /**                                                                                                                                                                                                                                    
      14                 :  * Main abstract compiler class                                                                                                                                                                                                        
      15                 :  *                                                                                                                                                                                                                                     
      16                 :  *                                                                                                                                                                                                                                     
      17                 :  * @package Compiler                                                                                                                                                                                                                   
      18                 :  */                                                                                                                                                                                                                                    
      19                 : class Smarty_Compiler_Template_Compiler extends Smarty_Compiler                                                                                                                                                                        
      20               1 : {                                                                                                                                                                                                                                      
      21                 :                                                                                                                                                                                                                                        
      22                 :     /**                                                                                                                                                                                                                                
      23                 :      * current template                                                                                                                                                                                                                
      24                 :      *                                                                                                                                                                                                                                 
      25                 :      * @var Smarty                                                                                                                                                                                                                     
      26                 :      */                                                                                                                                                                                                                                
      27                 :     public $tpl_obj = null;                                                                                                                                                                                                            
      28                 :                                                                                                                                                                                                                                        
      29                 :     /**                                                                                                                                                                                                                                
      30                 :      * source object                                                                                                                                                                                                                   
      31                 :      *                                                                                                                                                                                                                                 
      32               1 :      * @var Smarty_Resource                                                                                                                                                                                                            
      33                 :      */                                                                                                                                                                                                                                
      34                 :     public $source = null;                                                                                                                                                                                                             
      35                 :                                                                                                                                                                                                                                        
      36                 :     /**                                                                                                                                                                                                                                
      37                 :      * Lexer class name                                                                                                                                                                                                                
      38                 :      *                                                                                                                                                                                                                                 
      39                 :      * @var string                                                                                                                                                                                                                     
      40                 :      */                                                                                                                                                                                                                                
      41                 :     public $lexer_class = '';                                                                                                                                                                                                          
      42                 :                                                                                                                                                                                                                                        
      43                 :     /**                                                                                                                                                                                                                                
      44                 :      * Flag if caching enabled                                                                                                                                                                                                         
      45                 :      * @var boolean                                                                                                                                                                                                                    
      46                 :      */                                                                                                                                                                                                                                
      47               1 :     public $caching = false;                                                                                                                                                                                                           
      48                 :                                                                                                                                                                                                                                        
      49                 :     /**                                                                                                                                                                                                                                
      50                 :      * Parser class name                                                                                                                                                                                                               
      51                 :      *                                                                                                                                                                                                                                 
      52                 :      * @var string                                                                                                                                                                                                                     
      53                 :      */                                                                                                                                                                                                                                
      54                 :     public $parser_class = '';                                                                                                                                                                                                         
      55                 :                                                                                                                                                                                                                                        
      56                 :     /**                                                                                                                                                                                                                                
      57                 :      * Lexer object                                                                                                                                                                                                                    
      58                 :      *                                                                                                                                                                                                                                 
      59                 :      * @var object                                                                                                                                                                                                                     
      60                 :      */                                                                                                                                                                                                                                
      61                 :     public $lex = null;                                                                                                                                                                                                                
      62                 :                                                                                                                                                                                                                                        
      63                 :     /**                                                                                                                                                                                                                                
      64                 :      * Parser object                                                                                                                                                                                                                   
      65                 :      *                                                                                                                                                                                                                                 
      66                 :      * @var object                                                                                                                                                                                                                     
      67                 :      */                                                                                                                                                                                                                                
      68                 :     public $parser = null;                                                                                                                                                                                                             
      69                 :                                                                                                                                                                                                                                        
      70                 :     /**                                                                                                                                                                                                                                
      71                 :      * line offset to start of template source                                                                                                                                                                                         
      72                 :      *                                                                                                                                                                                                                                 
      73               5 :      * @var int                                                                                                                                                                                                                        
      74                 :      */                                                                                                                                                                                                                                
      75                 :     public $line_offset = 0;                                                                                                                                                                                                           
      76                 :                                                                                                                                                                                                                                        
      77                 :     /**                                                                                                                                                                                                                                
      78               5 :      * inline template code templates                                                                                                                                                                                                  
      79                 :      *                                                                                                                                                                                                                                 
      80                 :      * @var array                                                                                                                                                                                                                      
      81                 :      */                                                                                                                                                                                                                                
      82                 :     public static $merged_inline_content_classes = array();                                                                                                                                                                            
      83                 :                                                                                                                                                                                                                                        
      84                 :     /**                                                                                                                                                                                                                                
      85                 :      * flag for nocache section                                                                                                                                                                                                        
      86                 :      *                                                                                                                                                                                                                                 
      87                 :      * @var bool                                                                                                                                                                                                                       
      88                 :      */                                                                                                                                                                                                                                
      89               9 :     public $nocache = false;                                                                                                                                                                                                           
      90                 :                                                                                                                                                                                                                                        
      91               1 :     /**                                                                                                                                                                                                                                
      92                 :      * flag for nocache tag                                                                                                                                                                                                            
      93                 :      *                                                                                                                                                                                                                                 
      94                 :      * @var bool                                                                                                                                                                                                                       
      95                 :      */                                                                                                                                                                                                                                
      96                 :     public $tag_nocache = false;                                                                                                                                                                                                       
      97                 :                                                                                                                                                                                                                                        
      98                 :     /**                                                                                                                                                                                                                                
      99                 :      * flag for nocache code not setting $has_nocache_flag                                                                                                                                                                             
     100                 :      *                                                                                                                                                                                                                                 
     101                 :      * @var bool                                                                                                                                                                                                                       
     102                 :      */                                                                                                                                                                                                                                
     103                 :     public $nocache_nolog = false;                                                                                                                                                                                                     
     104                 :                                                                                                                                                                                                                                        
     105                 :     /**                                                                                                                                                                                                                                
     106                 :      * suppress generation of nocache code                                                                                                                                                                                             
     107                 :      *                                                                                                                                                                                                                                 
     108                 :      * @var bool                                                                                                                                                                                                                       
     109                 :      */                                                                                                                                                                                                                                
     110                 :     public $suppressNocacheProcessing = false;                                                                                                                                                                                         
     111                 :                                                                                                                                                                                                                                        
     112                 :     /**                                                                                                                                                                                                                                
     113                 :      * flag when compiling inheritance                                                                                                                                                                                                 
     114                 :      *                                                                                                                                                                                                                                 
     115              30 :      * @var bool                                                                                                                                                                                                                       
     116                 :      */                                                                                                                                                                                                                                
     117                 :     public $isInheritance = false;                                                                                                                                                                                                     
     118               2 :                                                                                                                                                                                                                                        
     119               2 :     /**                                                                                                                                                                                                                                
     120                 :      * flag when compiling inheritance                                                                                                                                                                                                 
     121                 :      *                                                                                                                                                                                                                                 
     122                 :      * @var bool                                                                                                                                                                                                                       
     123                 :      */                                                                                                                                                                                                                                
     124                 :     public $isInheritanceChild = false;                                                                                                                                                                                                
     125                 :                                                                                                                                                                                                                                        
     126                 :     /**                                                                                                                                                                                                                                
     127                 :      * force compilation of complete template as nocache                                                                                                                                                                               
     128                 :      * 0 = off                                                                                                                                                                                                                         
     129                 :      * 1 = observe nocache flags on template type recompiled                                                                                                                                                                           
     130                 :      * 2 = force all code to be nocache                                                                                                                                                                                                
     131                 :      *                                                                                                                                                                                                                                 
     132                 :      * @var integer                                                                                                                                                                                                                    
     133                 :      */                                                                                                                                                                                                                                
     134                 :     public $forceNocache = 0;                                                                                                                                                                                                          
     135                 :                                                                                                                                                                                                                                        
     136                 :     /**                                                                                                                                                                                                                                
     137                 :      * compile tag objects                                                                                                                                                                                                             
     138                 :      *                                                                                                                                                                                                                                 
     139                 :      * @var array                                                                                                                                                                                                                      
     140                 :      */                                                                                                                                                                                                                                
     141                 :     public static $_tag_objects = array();                                                                                                                                                                                             
     142                 :                                                                                                                                                                                                                                        
     143                 :     /**                                                                                                                                                                                                                                
     144                 :      * tag stack                                                                                                                                                                                                                       
     145                 :      *                                                                                                                                                                                                                                 
     146                 :      * @var array                                                                                                                                                                                                                      
     147              27 :      */                                                                                                                                                                                                                                
     148                 :     public $_tag_stack = array();                                                                                                                                                                                                      
     149                 :                                                                                                                                                                                                                                        
     150                 :     /**                                                                                                                                                                                                                                
     151                 :      * file dependencies                                                                                                                                                                                                               
     152                 :      *                                                                                                                                                                                                                                 
     153                 :      * @var array                                                                                                                                                                                                                      
     154                 :      */                                                                                                                                                                                                                                
     155                 :     public $file_dependency = array();                                                                                                                                                                                                 
     156               8 :                                                                                                                                                                                                                                        
     157                 :     /**                                                                                                                                                                                                                                
     158                 :      * template function properties                                                                                                                                                                                                    
     159                 :      *                                                                                                                                                                                                                                 
     160                 :      * @var array                                                                                                                                                                                                                      
     161                 :      */                                                                                                                                                                                                                                
     162                 :     public $template_functions = array();                                                                                                                                                                                              
     163                 :                                                                                                                                                                                                                                        
     164                 :     /**                                                                                                                                                                                                                                
     165                 :      * template function compiled code                                                                                                                                                                                                 
     166                 :      *                                                                                                                                                                                                                                 
     167                 :      * @var array                                                                                                                                                                                                                      
     168                 :      */                                                                                                                                                                                                                                
     169                 :     public $template_functions_code = array();                                                                                                                                                                                         
     170                 :                                                                                                                                                                                                                                        
     171                 :     /**                                                                                                                                                                                                                                
     172                 :      * block function properties                                                                                                                                                                                                       
     173                 :      *                                                                                                                                                                                                                                 
     174                 :      * @var array                                                                                                                                                                                                                      
     175                 :      */                                                                                                                                                                                                                                
     176                 :     public $inheritance_blocks = array();                                                                                                                                                                                              
     177                 :                                                                                                                                                                                                                                        
     178                 :     /**                                                                                                                                                                                                                                
     179                 :      * block function compiled code                                                                                                                                                                                                    
     180                 :      *                                                                                                                                                                                                                                 
     181                 :      * @var array                                                                                                                                                                                                                      
     182                 :      */                                                                                                                                                                                                                                
     183                 :     public $inheritance_blocks_code = array();                                                                                                                                                                                         
     184                 :                                                                                                                                                                                                                                        
     185                 :     /**                                                                                                                                                                                                                                
     186                 :      * block name index                                                                                                                                                                                                                
     187                 :      *                                                                                                                                                                                                                                 
     188                 :      * @var integer                                                                                                                                                                                                                    
     189                 :      */                                                                                                                                                                                                                                
     190                 :     public $block_name_index = 0;                                                                                                                                                                                                      
     191                 :                                                                                                                                                                                                                                        
     192                 :     /**                                                                                                                                                                                                                                
     193                 :      * inheritance block nesting level                                                                                                                                                                                                 
     194                 :      *                                                                                                                                                                                                                                 
     195                 :      * @var integer                                                                                                                                                                                                                    
     196                 :      */                                                                                                                                                                                                                                
     197                 :     public $block_nesting_level = 0;                                                                                                                                                                                                   
     198                 :                                                                                                                                                                                                                                        
     199                 :     /**                                                                                                                                                                                                                                
     200                 :      * block nesting info                                                                                                                                                                                                              
     201                 :      *                                                                                                                                                                                                                                 
     202                 :      * @var array                                                                                                                                                                                                                      
     203                 :      */                                                                                                                                                                                                                                
     204                 :     public $block_nesting_info = array();                                                                                                                                                                                              
     205                 :                                                                                                                                                                                                                                        
     206                 :     /**                                                                                                                                                                                                                                
     207                 :      * compiled footer code                                                                                                                                                                                                            
     208                 :      *                                                                                                                                                                                                                                 
     209                 :      * @var array                                                                                                                                                                                                                      
     210                 :      */                                                                                                                                                                                                                                
     211                 :     public $compiled_footer_code = null;                                                                                                                                                                                               
     212                 :                                                                                                                                                                                                                                        
     213                 :     /**                                                                                                                                                                                                                                
     214                 :                                                                                                                                                                                                                                        
     215                 :     /**                                                                                                                                                                                                                                
     216                 :      * plugins loaded by default plugin handler                                                                                                                                                                                        
     217                 :      *                                                                                                                                                                                                                                 
     218                 :      * @var array                                                                                                                                                                                                                      
     219                 :      */                                                                                                                                                                                                                                
     220                 :     public $default_handler_plugins = array();                                                                                                                                                                                         
     221                 :                                                                                                                                                                                                                                        
     222                 :     /**                                                                                                                                                                                                                                
     223                 :      * saved preprocessed modifier list                                                                                                                                                                                                
     224                 :      *                                                                                                                                                                                                                                 
     225                 :      * @var mixed                                                                                                                                                                                                                      
     226                 :      */                                                                                                                                                                                                                                
     227                 :     public $default_modifier_list = null;                                                                                                                                                                                              
     228                 :                                                                                                                                                                                                                                        
     229                 :     /**                                                                                                                                                                                                                                
     230                 :      * suppress template property header code in compiled template                                                                                                                                                                     
     231                 :      * @var bool                                                                                                                                                                                                                       
     232                 :      */                                                                                                                                                                                                                                
     233                 :     public $suppressTemplatePropertyHeader = false;                                                                                                                                                                                    
     234                 :                                                                                                                                                                                                                                        
     235                 :     /**                                                                                                                                                                                                                                
     236                 :      * suppress processing of post filter                                                                                                                                                                                              
     237                 :      * @var bool                                                                                                                                                                                                                       
     238                 :      */                                                                                                                                                                                                                                
     239                 :     public $suppressPostFilter = false;                                                                                                                                                                                                
     240                 :                                                                                                                                                                                                                                        
     241                 :     /**                                                                                                                                                                                                                                
     242                 :      * flag if compiled template file shall we written                                                                                                                                                                                 
     243                 :      * @var bool                                                                                                                                                                                                                       
     244                 :      */                                                                                                                                                                                                                                
     245                 :     public $write_compiled_code = true;                                                                                                                                                                                                
     246                 :                                                                                                                                                                                                                                        
     247                 :     /**                                                                                                                                                                                                                                
     248                 :      * flag if template does contain nocache code sections                                                                                                                                                                             
     249                 :      * @var boolean                                                                                                                                                                                                                    
     250                 :      */                                                                                                                                                                                                                                
     251                 :     public $has_nocache_code = false;                                                                                                                                                                                                  
     252                 :                                                                                                                                                                                                                                        
     253                 :     /**                                                                                                                                                                                                                                
     254                 :      * flag if currently a template function is compiled                                                                                                                                                                               
     255                 :      * @var bool                                                                                                                                                                                                                       
     256                 :      */                                                                                                                                                                                                                                
     257                 :     public $compiles_template_function = false;                                                                                                                                                                                        
     258                 :                                                                                                                                                                                                                                        
     259                 :     /**                                                                                                                                                                                                                                
     260                 :      * called subfuntions from template function                                                                                                                                                                                       
     261                 :      * @var array                                                                                                                                                                                                                      
     262                 :      */                                                                                                                                                                                                                                
     263                 :     public $called_template_functions = array();                                                                                                                                                                                       
     264                 :                                                                                                                                                                                                                                        
     265                 :     /**                                                                                                                                                                                                                                
     266                 :      * template functions called nocache                                                                                                                                                                                               
     267                 :      * @var array                                                                                                                                                                                                                      
     268                 :      */                                                                                                                                                                                                                                
     269                 :     public $called_nocache_template_functions = array();                                                                                                                                                                               
     270                 :                                                                                                                                                                                                                                        
     271                 :     /**                                                                                                                                                                                                                                
     272                 :      * content class name                                                                                                                                                                                                              
     273                 :      * @var string                                                                                                                                                                                                                     
     274                 :      */                                                                                                                                                                                                                                
     275                 :     public $content_class = '';                                                                                                                                                                                                        
     276                 :                                                                                                                                                                                                                                        
     277                 :     /**                                                                                                                                                                                                                                
     278                 :      * required plugins                                                                                                                                                                                                                
     279                 :      * @var array                                                                                                                                                                                                                      
     280                 :      * @internal                                                                                                                                                                                                                       
     281                 :      */                                                                                                                                                                                                                                
     282                 :     public $required_plugins = array('compiled' => array(), 'nocache' => array());                                                                                                                                                     
     283                 :                                                                                                                                                                                                                                        
     284                 :     /**                                                                                                                                                                                                                                
     285                 :      * flags for used modifier plugins                                                                                                                                                                                                 
     286                 :      * @var array                                                                                                                                                                                                                      
     287                 :      */                                                                                                                                                                                                                                
     288                 :     public $modifier_plugins = array();                                                                                                                                                                                                
     289                 :                                                                                                                                                                                                                                        
     290                 :     /**                                                                                                                                                                                                                                
     291                 :      * type of already compiled modifier                                                                                                                                                                                               
     292                 :      * @var array                                                                                                                                                                                                                      
     293                 :      */                                                                                                                                                                                                                                
     294                 :     public $known_modifier_type = array();                                                                                                                                                                                             
     295                 :                                                                                                                                                                                                                                        
     296                 :     /**                                                                                                                                                                                                                                
     297                 :      * Code object for generated template code                                                                                                                                                                                         
     298                 :      * @var Smarty_Compiler_Code                                                                                                                                                                                                       
     299                 :      */                                                                                                                                                                                                                                
     300                 :     public $template_code = null;                                                                                                                                                                                                      
     301                 :                                                                                                                                                                                                                                        
     302                 :     // TODO check this solution                                                                                                                                                                                                        
     303                 :     public $prefix_code = array();                                                                                                                                                                                                     
     304                 :     public $postfix_code = array();                                                                                                                                                                                                    
     305                 :     public $has_code = false;                                                                                                                                                                                                          
     306                 :     public $has_output = false;                                                                                                                                                                                                        
     307                 :                                                                                                                                                                                                                                        
     308                 :     /**                                                                                                                                                                                                                                
     309                 :      * Initialize compiler                                                                                                                                                                                                             
     310                 :      *                                                                                                                                                                                                                                 
     311                 :      * @param string          $lexer_class  class name                                                                                                                                                                                 
     312                 :      * @param string          $parser_class class name                                                                                                                                                                                 
     313                 :      * @param Smarty_Resource $source                                                                                                                                                                                                  
     314                 :      * @param boolean         $caching      flag if caching enabled                                                                                                                                                                    
     315                 :      * @param Smarty          $tpl_obj                                                                                                                                                                                                 
     316                 :      */                                                                                                                                                                                                                                
     317                 :     public function __construct($lexer_class, $parser_class, $tpl_obj, $source, $caching)                                                                                                                                              
     318                 :     {                                                                                                                                                                                                                                  
     319                 :         //parent::__construct();                                                                                                                                                                                                       
     320                 :                                                                                                                                                                                                                                        
     321             905 :         $this->tpl_obj = $tpl_obj;                                                                                                                                                                                                     
     322             905 :         $this->source = $source;                                                                                                                                                                                                       
     323             905 :         $this->caching = $caching;                                                                                                                                                                                                     
     324                 :         // get required plugins                                                                                                                                                                                                        
     325             905 :         $this->lexer_class = $lexer_class;                                                                                                                                                                                             
     326             905 :         $this->parser_class = $parser_class;                                                                                                                                                                                           
     327                 :         // init code buffer                                                                                                                                                                                                            
     328             905 :         $this->template_code = new Smarty_Compiler_Code(3);                                                                                                                                                                            
     329             905 :         $this->template_code->addSourceLineNo(1);                                                                                                                                                                                      
     330                 :                                                                                                                                                                                                                                        
     331             905 :     }                                                                                                                                                                                                                                  
     332                 :                                                                                                                                                                                                                                        
     333                 :     /**                                                                                                                                                                                                                                
     334                 :      * Method to compile a Smarty template                                                                                                                                                                                             
     335                 :      *                                                                                                                                                                                                                                 
     336                 :      * @param  mixed $_content template source                                                                                                                                                                                         
     337                 :      * @return bool  true if compiling succeeded, false if it failed                                                                                                                                                                   
     338                 :      */                                                                                                                                                                                                                                
     339                 :                                                                                                                                                                                                                                        
     340                 :     /**                                                                                                                                                                                                                                
     341                 :      * Method to compile a Smarty template                                                                                                                                                                                             
     342                 :      *                                                                                                                                                                                                                                 
     343                 :      * @param  mixed $_content template source                                                                                                                                                                                         
     344                 :      * @return bool  true if compiling succeeded, false if it failed                                                                                                                                                                   
     345                 :      */                                                                                                                                                                                                                                
     346                 :     protected function doCompile($_content = null)                                                                                                                                                                                     
     347                 :     {                                                                                                                                                                                                                                  
     348                 :         /* here is where the compiling takes place. Smarty                                                                                                                                                                             
     349                 :           tags in the templates are replaces with PHP code,                                                                                                                                                                            
     350                 :           then written to compiled files. */                                                                                                                                                                                           
     351                 :                                                                                                                                                                                                                                        
     352             896 :         if ($this->tpl_obj->_parserdebug)                                                                                                                                                                                              
     353             896 :             $this->parser->PrintTrace();                                                                                                                                                                                               
     354                 :         // get tokens from lexer and parse them                                                                                                                                                                                        
     355             896 :         while ($this->lex->yylex()) {                                                                                                                                                                                                  
     356             895 :             if ($this->tpl_obj->_parserdebug) {                                                                                                                                                                                        
     357               0 :                 echo "<pre>Line {$this->lex->line} Parsing  {$this->parser->yyTokenName[$this->lex->token]} Token " .                                                                                                                  
     358               0 :                     htmlentities($this->lex->value) . "</pre>";                                                                                                                                                                        
     359               0 :             }                                                                                                                                                                                                                          
     360             895 :             $this->parser->doParse($this->lex->token, $this->lex->value);                                                                                                                                                              
     361             895 :         }                                                                                                                                                                                                                              
     362                 :                                                                                                                                                                                                                                        
     363                 :         // finish parsing process                                                                                                                                                                                                      
     364             854 :         $this->parser->doParse(0, 0);                                                                                                                                                                                                  
     365                 :         // check for unclosed tags                                                                                                                                                                                                     
     366             837 :         if (count($this->_tag_stack) > 0) {                                                                                                                                                                                            
     367                 :             // get stacked info                                                                                                                                                                                                        
     368               1 :             list($openTag, $_data) = array_pop($this->_tag_stack);                                                                                                                                                                     
     369               1 :             $this->trigger_template_error("unclosed {" . $openTag . "} tag");                                                                                                                                                          
     370               0 :         }                                                                                                                                                                                                                              
     371                 :         // return compiled code                                                                                                                                                                                                        
     372                 :         // return str_replace(array("? >\n<?php","? ><?php"), array('',''), $this->parser->retvalue);                                                                                                                                  
     373             836 :         return $this->parser->retvalue;                                                                                                                                                                                                
     374                 :     }                                                                                                                                                                                                                                  
     375                 :                                                                                                                                                                                                                                        
     376                 :     /**                                                                                                                                                                                                                                
     377                 :      * Compiles the template source                                                                                                                                                                                                    
     378                 :      *                                                                                                                                                                                                                                 
     379                 :      * If the template is not evaluated the compiled template is saved on disk                                                                                                                                                         
     380                 :      *                                                                                                                                                                                                                                 
     381                 :      * @throws Smarty_Exception in case of compilation errors                                                                                                                                                                          
     382                 :      * @throws Exception                                                                                                                                                                                                               
     383                 :      */                                                                                                                                                                                                                                
     384                 :     public function compileTemplateSource(Smarty_Compiled_Resource $compiled)                                                                                                                                                          
     385                 :     {                                                                                                                                                                                                                                  
     386             180 :         $this->isInheritance = $this->isInheritanceChild = $this->tpl_obj->is_inheritance_child;                                                                                                                                       
     387             180 :         if (!$this->source->recompiled) {                                                                                                                                                                                              
     388             180 :             if ($this->source->components) {                                                                                                                                                                                           
     389                 :                 // uses real resource for file dependency                                                                                                                                                                              
     390              10 :                 $source = end($this->source->components);                                                                                                                                                                              
     391              10 :             } else {                                                                                                                                                                                                                   
     392             171 :                 $source = $this->source;                                                                                                                                                                                               
     393                 :             }                                                                                                                                                                                                                          
     394             180 :             $this->file_dependency[$this->source->uid] = array($this->source->filepath, $this->source->timestamp, $source->type);                                                                                                      
     395             180 :         }                                                                                                                                                                                                                              
     396             180 :         if ($this->tpl_obj->debugging) {                                                                                                                                                                                               
     397               0 :             Smarty_Debug::start_compile($this->tpl_obj);                                                                                                                                                                               
     398               0 :         }                                                                                                                                                                                                                              
     399                 :         // compile locking                                                                                                                                                                                                             
     400             180 :         if ($this->tpl_obj->compile_locking && !$this->source->recompiled) {                                                                                                                                                           
     401             180 :             if ($saved_timestamp = $compiled->timestamp) {                                                                                                                                                                             
     402              17 :                 touch($compiled->filepath);                                                                                                                                                                                            
     403              17 :             }                                                                                                                                                                                                                          
     404             180 :         }                                                                                                                                                                                                                              
     405                 :         // call compiler                                                                                                                                                                                                               
     406                 :         try {                                                                                                                                                                                                                          
     407             180 :             $code = $this->compileTemplate();                                                                                                                                                                                          
     408             180 :         } catch (Exception $e) {                                                                                                                                                                                                       
     409                 :             // restore old timestamp in case of error                                                                                                                                                                                  
     410              42 :             if ($this->tpl_obj->compile_locking && !$this->source->recompiled && $saved_timestamp) {                                                                                                                                   
     411               0 :                 touch($compiled->filepath, $saved_timestamp);                                                                                                                                                                          
     412               0 :             }                                                                                                                                                                                                                          
     413              42 :             throw $e;                                                                                                                                                                                                                  
     414                 :         }                                                                                                                                                                                                                              
     415                 :         // compiling succeded                                                                                                                                                                                                          
     416             140 :         if (!$this->source->recompiled && $this->write_compiled_code) {                                                                                                                                                                
     417                 :             // write compiled template                                                                                                                                                                                                 
     418             140 :             $_filepath = $compiled->filepath;                                                                                                                                                                                          
     419             140 :             if ($_filepath === false)                                                                                                                                                                                                  
     420             140 :                 throw new Smarty_Exception('Invalid filepath for compiled template');                                                                                                                                                  
     421             140 :             Smarty_Misc_WriteFile::writeFile($_filepath, $code, $this->tpl_obj);                                                                                                                                                       
     422             140 :             $compiled->exists = true;                                                                                                                                                                                                  
     423             140 :             $compiled->isCompiled = true;                                                                                                                                                                                              
     424             140 :         }                                                                                                                                                                                                                              
     425             140 :         if ($this->tpl_obj->debugging) {                                                                                                                                                                                               
     426               0 :             Smarty_Debug::end_compile($this->tpl_obj);                                                                                                                                                                                 
     427               0 :         }                                                                                                                                                                                                                              
     428             140 :     }                                                                                                                                                                                                                                  
     429                 :                                                                                                                                                                                                                                        
     430                 :     /**                                                                                                                                                                                                                                
     431                 :      * Method to compile a Smarty template                                                                                                                                                                                             
     432                 :      *                                                                                                                                                                                                                                 
     433                 :      * @return bool true if compiling succeeded, false if it failed                                                                                                                                                                    
     434                 :      */                                                                                                                                                                                                                                
     435                 :     public function compileTemplate()                                                                                                                                                                                                  
     436                 :     {                                                                                                                                                                                                                                  
     437                 :         // flag for nochache sections                                                                                                                                                                                                  
     438                 :         //        $this->nocache = false;                                                                                                                                                                                              
     439             905 :         $this->tag_nocache = false;                                                                                                                                                                                                    
     440                 :         // reset has nocache code flag                                                                                                                                                                                                 
     441             905 :         $this->has_nocache_code = false;                                                                                                                                                                                               
     442                 :         // check if content class name already predefine                                                                                                                                                                               
     443             905 :         if (empty($this->content_class)) {                                                                                                                                                                                             
     444             905 :             $this->content_class = '_SmartyTemplate_' . str_replace('.', '_', uniqid('', true));                                                                                                                                       
     445             905 :         }                                                                                                                                                                                                                              
     446             905 :         $this->tpl_obj->_current_file = $saved_filepath = $this->source->filepath;                                                                                                                                                     
     447                 :                                                                                                                                                                                                                                        
     448                 :         // make sure that we don't run into backtrack limit errors                                                                                                                                                                     
     449             905 :         ini_set('pcre.backtrack_limit', -1);                                                                                                                                                                                           
     450                 :         // init the lexer/parser to compile the template                                                                                                                                                                               
     451             905 :         $this->lex = new $this->lexer_class(null, $this);                                                                                                                                                                              
     452             905 :         $this->parser = new $this->parser_class($this->lex, $this);                                                                                                                                                                    
     453                 :                                                                                                                                                                                                                                        
     454                 :                                                                                                                                                                                                                                        
     455                 :         // get source and run prefilter if required and pass iit to lexer                                                                                                                                                              
     456             905 :         if (isset($this->tpl_obj->autoload_filters['pre']) || isset($this->tpl_obj->registered_filters['pre'])) {                                                                                                                      
     457               4 :             $this->lex->data = Smarty_Misc_FilterHandler::runFilter('pre', $this->source->content, $this->tpl_obj);                                                                                                                    
     458               4 :         } else {                                                                                                                                                                                                                       
     459             901 :             $this->lex->data = $this->source->getContent();                                                                                                                                                                            
     460                 :         }                                                                                                                                                                                                                              
     461                 :         // call compiler                                                                                                                                                                                                               
     462             896 :         $this->doCompile();                                                                                                                                                                                                            
     463                 :                                                                                                                                                                                                                                        
     464             836 :         $this->source->filepath = $saved_filepath;                                                                                                                                                                                     
     465                 :         // free memory                                                                                                                                                                                                                 
     466             836 :         $this->parser->compiler = null;                                                                                                                                                                                                
     467             836 :         $this->parser = null;                                                                                                                                                                                                          
     468             836 :         $this->lex->compiler = null;                                                                                                                                                                                                   
     469             836 :         $this->lex = null;                                                                                                                                                                                                             
     470             836 :         self::$_tag_objects = array();                                                                                                                                                                                                 
     471                 :         // return compiled code to template object                                                                                                                                                                                     
     472                 :         // run postfilter if required on compiled template code                                                                                                                                                                        
     473             836 :         if (!$this->suppressPostFilter && (isset($this->tpl_obj->autoload_filters['post']) || isset($this->tpl_obj->registered_filters['post']))) {                                                                                    
     474               3 :             $this->template_code->buffer = Smarty_Misc_FilterHandler::runFilter('post', $this->template_code->buffer, $this->tpl_obj);                                                                                                 
     475               3 :         }                                                                                                                                                                                                                              
     476             836 :         if (!$this->suppressTemplatePropertyHeader) {                                                                                                                                                                                  
     477             836 :             $this->content_class = '_SmartyTemplate_' . str_replace('.', '_', uniqid('', true));                                                                                                                                       
     478             836 :             $this->template_code = $this->_createSmartyContentClass($this->tpl_obj);                                                                                                                                                   
     479             813 :         }                                                                                                                                                                                                                              
     480                 :                                                                                                                                                                                                                                        
     481             813 :         return $this->template_code->buffer;                                                                                                                                                                                           
     482                 :     }                                                                                                                                                                                                                                  
     483                 :                                                                                                                                                                                                                                        
     484                 :     /**                                                                                                                                                                                                                                
     485                 :      * Compile Tag                                                                                                                                                                                                                     
     486                 :      *                                                                                                                                                                                                                                 
     487                 :      * This is a call back from the lexer/parser                                                                                                                                                                                       
     488                 :      * It executes the required compile plugin for the Smarty tag                                                                                                                                                                      
     489                 :      *                                                                                                                                                                                                                                 
     490                 :      * @param  string $tag       tag name                                                                                                                                                                                              
     491                 :      * @param  array  $args      array with tag attributes                                                                                                                                                                             
     492                 :      * @param  array  $parameter array with compilation parameter                                                                                                                                                                      
     493                 :      * @return string compiled code                                                                                                                                                                                                    
     494                 :      */                                                                                                                                                                                                                                
     495                 :     public function compileTag($tag, $args, $parameter = array())                                                                                                                                                                      
     496                 :     {                                                                                                                                                                                                                                  
     497                 :         // $args contains the attributes parsed and compiled by the lexer/parser                                                                                                                                                       
     498                 :         // assume that tag does compile into code, but creates no HTML output                                                                                                                                                          
     499             807 :         $this->has_code = true;                                                                                                                                                                                                        
     500             807 :         $this->has_output = false;                                                                                                                                                                                                     
     501                 :         // log tag/attributes                                                                                                                                                                                                          
     502             807 :         if (isset($this->tpl_obj->get_used_tags) && $this->tpl_obj->get_used_tags) {                                                                                                                                                   
     503               0 :             $this->tpl_obj->used_tags[] = array($tag, $args);                                                                                                                                                                          
     504               0 :         }                                                                                                                                                                                                                              
     505                 :         // check nocache option flag                                                                                                                                                                                                   
     506             807 :         if (in_array("'nocache'", $args) || in_array(array('nocache' => 'true'), $args)                                                                                                                                                
     507             807 :             || in_array(array('nocache' => '"true"'), $args) || in_array(array('nocache' => "'true'"), $args)                                                                                                                          
     508             807 :         ) {                                                                                                                                                                                                                            
     509               9 :             $this->tag_nocache = true;                                                                                                                                                                                                 
     510               9 :         }                                                                                                                                                                                                                              
     511                 :         // compile the smarty tag (required compile classes to compile the tag are autoloaded)                                                                                                                                         
     512             807 :         if (($_output = $this->compileCoreTag($tag, $args, $parameter)) === false) {                                                                                                                                                   
     513             217 :             if (isset($this->template_functions[$tag])) {                                                                                                                                                                              
     514                 :                 // template defined by {template} tag                                                                                                                                                                                  
     515               0 :                 $args['_attr']['name'] = "'" . $tag . "'";                                                                                                                                                                             
     516               0 :                 $_output = $this->compileCoreTag('Call', $args, $parameter);                                                                                                                                                           
     517               0 :             }                                                                                                                                                                                                                          
     518             217 :         }                                                                                                                                                                                                                              
     519             795 :         if ($_output !== false) {                                                                                                                                                                                                      
     520             617 :             if ($_output !== true) {                                                                                                                                                                                                   
     521                 :                 // did we get compiled code                                                                                                                                                                                            
     522             615 :                 if ($this->has_code) {                                                                                                                                                                                                 
     523                 :                     // return compiled code                                                                                                                                                                                            
     524             615 :                     return $_output;                                                                                                                                                                                                   
     525                 :                 }                                                                                                                                                                                                                      
     526               0 :             }                                                                                                                                                                                                                          
     527                 :             // tag did not produce compiled code                                                                                                                                                                                       
     528              48 :             return '';                                                                                                                                                                                                                 
     529                 :         } else {                                                                                                                                                                                                                       
     530                 :             // map_named attributes                                                                                                                                                                                                    
     531             217 :             if (isset($args['_attr'])) {                                                                                                                                                                                               
     532               0 :                 foreach ($args['_attr'] as $attribute) {                                                                                                                                                                               
     533               0 :                     if (is_array($attribute)) {                                                                                                                                                                                        
     534               0 :                         $args = array_merge($args, $attribute);                                                                                                                                                                        
     535               0 :                     }                                                                                                                                                                                                                  
     536               0 :                 }                                                                                                                                                                                                                      
     537               0 :             }                                                                                                                                                                                                                          
     538                 :             // not an internal compiler tag                                                                                                                                                                                            
     539             217 :             if (strlen($tag) < 6 || substr($tag, -5) != 'close') {                                                                                                                                                                     
     540                 :                 // check if tag is a registered object                                                                                                                                                                                 
     541             217 :                 if (isset($this->tpl_obj->registered_objects[$tag]) && isset($parameter['object_method'])) {                                                                                                                           
     542               5 :                     $method = $parameter['object_method'];                                                                                                                                                                             
     543               5 :                     if (!in_array($method, $this->tpl_obj->registered_objects[$tag][3]) &&                                                                                                                                             
     544               2 :                         (empty($this->tpl_obj->registered_objects[$tag][1]) || in_array($method, $this->tpl_obj->registered_objects[$tag][1]))                                                                                         
     545               5 :                     ) {                                                                                                                                                                                                                
     546               2 :                         return $this->compileCoreTag('Internal_ObjectFunction', $args, $parameter, $tag, $method);                                                                                                                     
     547               3 :                     } elseif (in_array($method, $this->tpl_obj->registered_objects[$tag][3])) {                                                                                                                                        
     548               3 :                         return $this->compileCoreTag('Internal_ObjectBlockFunction', $args, $parameter, $tag, $method);                                                                                                                
     549                 :                     } else {                                                                                                                                                                                                           
     550               0 :                         $this->trigger_template_error('unallowed method "' . $method . '" in registered object "' . $tag . '"', $this->lex->taglineno);                                                                                
     551                 :                     }                                                                                                                                                                                                                  
     552               0 :                 }                                                                                                                                                                                                                      
     553                 :                 // check if tag is registered                                                                                                                                                                                          
     554             212 :                 foreach (array(Smarty::PLUGIN_COMPILER, Smarty::PLUGIN_FUNCTION, Smarty::PLUGIN_BLOCK) as $plugin_type) {                                                                                                              
     555             212 :                     if (isset($this->tpl_obj->registered_plugins[$plugin_type][$tag])) {                                                                                                                                               
     556                 :                         // if compiler function plugin call it now                                                                                                                                                                     
     557              43 :                         if ($plugin_type == Smarty::PLUGIN_COMPILER) {                                                                                                                                                                 
     558               5 :                             return $this->compileCoreTag('Internal_PluginCompiler', $args, $parameter, $tag);                                                                                                                          
     559                 :                         }                                                                                                                                                                                                              
     560                 :                         // compile registered function or block function                                                                                                                                                               
     561              38 :                         if ($plugin_type == Smarty::PLUGIN_FUNCTION || $plugin_type == Smarty::PLUGIN_BLOCK) {                                                                                                                         
     562              38 :                             return $this->compileCoreTag('Internal_Registered' . ucfirst($plugin_type), $args, $parameter, $tag);                                                                                                      
     563                 :                         }                                                                                                                                                                                                              
     564               0 :                     }                                                                                                                                                                                                                  
     565             207 :                 }                                                                                                                                                                                                                      
     566                 :                 // check plugins from plugins folder                                                                                                                                                                                   
     567             169 :                 foreach ($this->tpl_obj->plugin_search_order as $plugin_type) {                                                                                                                                                        
     568             169 :                     if ($plugin_type == Smarty::PLUGIN_COMPILER && $this->tpl_obj->_loadPlugin('smarty_compiler_' . $tag) && (!isset($this->tpl_obj->security_policy) || $this->tpl_obj->security_policy->isTrustedTag($tag, $this))) {
     569               1 :                         $plugin = 'smarty_compiler_' . $tag;                                                                                                                                                                           
     570               1 :                         if (is_callable($plugin) || class_exists($plugin, false)) {                                                                                                                                                    
     571               1 :                             return $this->compileCoreTag('Internal_PluginCompiler', $args, $parameter, $tag);                                                                                                                          
     572                 :                         }                                                                                                                                                                                                              
     573               0 :                         $this->trigger_template_error("Plugin '{{$tag}...}' not callable", $this->lex->taglineno);                                                                                                                     
     574               0 :                     } else {                                                                                                                                                                                                           
     575             169 :                         if ($function = $this->getPlugin($tag, $plugin_type)) {                                                                                                                                                        
     576             139 :                             if (!isset($this->tpl_obj->security_policy) || $this->tpl_obj->security_policy->isTrustedTag($tag, $this)) {                                                                                               
     577             139 :                                 return $this->compileCoreTag('Internal_Plugin'. ucfirst($plugin_type), $args, $parameter, $tag, $function);                                                                                            
     578                 :                             }                                                                                                                                                                                                          
     579               0 :                         }                                                                                                                                                                                                              
     580                 :                     }                                                                                                                                                                                                                  
     581              51 :                 }                                                                                                                                                                                                                      
     582              29 :                 if (is_callable($this->tpl_obj->default_plugin_handler_func)) {                                                                                                                                                        
     583               6 :                     $found = false;                                                                                                                                                                                                    
     584                 :                     // look for already resolved tags                                                                                                                                                                                  
     585               6 :                     foreach ($this->tpl_obj->plugin_search_order as $plugin_type) {                                                                                                                                                    
     586               6 :                         if (isset($this->default_handler_plugins[$plugin_type][$tag])) {                                                                                                                                               
     587               0 :                             $found = true;                                                                                                                                                                                             
     588               0 :                             break;                                                                                                                                                                                                     
     589                 :                         }                                                                                                                                                                                                              
     590               6 :                     }                                                                                                                                                                                                                  
     591               6 :                     if (!$found) {                                                                                                                                                                                                     
     592                 :                         // call default handler                                                                                                                                                                                        
     593               6 :                         foreach ($this->tpl_obj->plugin_search_order as $plugin_type) {                                                                                                                                                
     594               6 :                             if ($this->getPluginFromDefaultHandler($tag, $plugin_type)) {                                                                                                                                              
     595               6 :                                 $found = true;                                                                                                                                                                                         
     596               6 :                                 break;                                                                                                                                                                                                 
     597                 :                             }                                                                                                                                                                                                          
     598               6 :                         }                                                                                                                                                                                                              
     599               6 :                     }                                                                                                                                                                                                                  
     600               6 :                     if ($found) {                                                                                                                                                                                                      
     601                 :                         // if compiler function plugin call it now                                                                                                                                                                     
     602               6 :                         if ($plugin_type == Smarty::PLUGIN_COMPILER) {                                                                                                                                                                 
     603               1 :                             return $this->compileCoreTag('Internal_PluginCompiler', $args, $parameter, $tag);                                                                                                                          
     604                 :                         } else {                                                                                                                                                                                                       
     605               5 :                             return $this->compileCoreTag('Internal_Registered' . ucfirst($plugin_type), $args, $parameter, $tag);                                                                                                      
     606                 :                         }                                                                                                                                                                                                              
     607                 :                     }                                                                                                                                                                                                                  
     608               0 :                 }                                                                                                                                                                                                                      
     609              23 :             } else {                                                                                                                                                                                                                   
     610                 :                 // compile closing tag of block function                                                                                                                                                                               
     611              46 :                 $base_tag = substr($tag, 0, -5);                                                                                                                                                                                       
     612                 :                 // check if closing tag is a registered object                                                                                                                                                                         
     613              46 :                 if (isset($this->tpl_obj->registered_objects[$base_tag]) && isset($parameter['object_method'])) {                                                                                                                      
     614               3 :                     $method = $parameter['object_method'];                                                                                                                                                                             
     615               3 :                     if (in_array($method, $this->tpl_obj->registered_objects[$base_tag][3])) {                                                                                                                                         
     616               3 :                         return $this->compileCoreTag('Internal_ObjectBlockFunction', $args, $parameter, $tag, $method);                                                                                                                
     617                 :                     } else {                                                                                                                                                                                                           
     618               0 :                         $this->trigger_template_error('unallowed closing tag method "' . $method . '" in registered object "' . $base_tag . '"', $this->lex->taglineno);                                                               
     619                 :                     }                                                                                                                                                                                                                  
     620               0 :                 }                                                                                                                                                                                                                      
     621                 :                 // registered compiler plugin ?                                                                                                                                                                                        
     622              43 :                 if (isset($this->tpl_obj->registered_plugins[Smarty::PLUGIN_COMPILER][$tag])) {                                                                                                                                        
     623               1 :                     return $this->compileCoreTag('Internal_PluginCompilerclose', $args, $parameter, $tag);                                                                                                                             
     624                 :                 }                                                                                                                                                                                                                      
     625                 :                 // registered block tag ?                                                                                                                                                                                              
     626              42 :                 if (isset($this->tpl_obj->registered_plugins[Smarty::PLUGIN_BLOCK][$base_tag]) || isset($this->default_handler_plugins[Smarty::PLUGIN_BLOCK][$base_tag])) {                                                            
     627              20 :                     return $this->compileCoreTag('Internal_RegisteredBlock', $args, $parameter, $tag);                                                                                                                                 
     628                 :                 }                                                                                                                                                                                                                      
     629                 :                 // block plugin?                                                                                                                                                                                                       
     630              22 :                 if ($function = $this->getPlugin($base_tag, Smarty::PLUGIN_BLOCK)) {                                                                                                                                                   
     631              21 :                     return $this->compileCoreTag('Internal_PluginBlock', $args, $parameter, $tag, $function);                                                                                                                          
     632                 :                 }                                                                                                                                                                                                                      
     633               1 :                 if ($this->tpl_obj->_loadPlugin('smarty_compiler_' . $tag)) {                                                                                                                                                          
     634               1 :                     return $this->compileCoreTag('Internal_PluginCompilerclose', $args, $parameter, $tag);                                                                                                                             
     635                 :                 }                                                                                                                                                                                                                      
     636               0 :                 $this->trigger_template_error("Plugin '{{$tag}...}' not callable", $this->lex->taglineno);                                                                                                                             
     637                 :             }                                                                                                                                                                                                                          
     638              23 :             $this->trigger_template_error("unknown tag '{{$tag}...}'", $this->lex->taglineno);                                                                                                                                         
     639                 :         }                                                                                                                                                                                                                              
     640               0 :     }                                                                                                                                                                                                                                  
     641                 :                                                                                                                                                                                                                                        
     642                 :     /**                                                                                                                                                                                                                                
     643                 :      * lazy loads internal compile plugin for tag and calls the compile method                                                                                                                                                         
     644                 :      *                                                                                                                                                                                                                                 
     645                 :      * compile objects cached for reuse.                                                                                                                                                                                               
     646                 :      * class name format:  Smarty_Compiler_Template_Tag_TagName                                                                                                                                                                        
     647                 :      *                                                                                                                                                                                                                                 
     648                 :      * @param  string $tag    tag name                                                                                                                                                                                                 
     649                 :      * @param  array  $args   list of tag attributes                                                                                                                                                                                   
     650                 :      * @param  mixed  $param1 optional parameter                                                                                                                                                                                       
     651                 :      * @param  mixed  $param2 optional parameter                                                                                                                                                                                       
     652                 :      * @param  mixed  $param3 optional parameter                                                                                                                                                                                       
     653                 :      * @return string compiled code                                                                                                                                                                                                    
     654                 :      */                                                                                                                                                                                                                                
     655                 :     public function compileCoreTag($tag, $args, $param1 = null, $param2 = null, $param3 = null)                                                                                                                                        
     656                 :     {                                                                                                                                                                                                                                  
     657                 :         // re-use object if already exists                                                                                                                                                                                             
     658             807 :         if (isset(self::$_tag_objects[$tag])) {                                                                                                                                                                                        
     659                 :             // compile this tag                                                                                                                                                                                                        
     660             179 :             return self::$_tag_objects[$tag]->compile($args, $this, $param1, $param2, $param3);                                                                                                                                        
     661                 :         }                                                                                                                                                                                                                              
     662                 :         // check if tag allowed by security                                                                                                                                                                                            
     663             794 :         if (!isset($this->tpl_obj->security_policy) || $this->tpl_obj->security_policy->isTrustedTag($tag, $this)) {                                                                                                                   
     664             794 :             $class = 'Smarty_Compiler_Template_Tag_' . $tag;                                                                                                                                                                           
     665             794 :             if (!class_exists($class, false)) {                                                                                                                                                                                        
     666             240 :                 if (is_file($file = SMARTY_DIR . str_replace(array('_', "\0"), array('/', ''), $class) . '.php')) {                                                                                                                    
     667              31 :                     require $file;                                                                                                                                                                                                     
     668              31 :                 } else {                                                                                                                                                                                                               
     669             217 :                     return false;                                                                                                                                                                                                      
     670                 :                 }                                                                                                                                                                                                                      
     671              31 :             }                                                                                                                                                                                                                          
     672             769 :             self::$_tag_objects[$tag] = new $class;                                                                                                                                                                                    
     673                 :             // compile this tag                                                                                                                                                                                                        
     674             769 :             return self::$_tag_objects[$tag]->compile($args, $this, $param1, $param2, $param3);                                                                                                                                        
     675                 :         }                                                                                                                                                                                                                              
     676                 :         // no internal compile plugin for this tag                                                                                                                                                                                     
     677               0 :         return false;                                                                                                                                                                                                                  
     678                 :     }                                                                                                                                                                                                                                  
     679                 :                                                                                                                                                                                                                                        
     680                 :     /**                                                                                                                                                                                                                                
     681                 :      * Compile code for template variable                                                                                                                                                                                              
     682                 :      *                                                                                                                                                                                                                                 
     683                 :      * @param  string $variable name of variable                                                                                                                                                                                       
     684                 :      * @return string code                                                                                                                                                                                                             
     685                 :      */                                                                                                                                                                                                                                
     686                 :     public function compileVariable($variable) {                                                                                                                                                                                       
     687             360 :         if (strpos($variable,'(') === false) {                                                                                                                                                                                         
     688                 :             // not a variable variable                                                                                                                                                                                                 
     689             360 :             $var = trim($variable,'\'"');                                                                                                                                                                                              
     690             360 :             $this->tag_nocache=$this->tag_nocache|$this->tpl_obj->getVariable($var, null, true, false, 'nocache');                                                                                                                     
     691                 : //                $this->compiler->tpl_obj->properties['variables'][$var] = $this->compiler->tag_nocache|$this->compiler->nocache;                                                                                                     
     692             360 :         } else {                                                                                                                                                                                                                       
     693               5 :             $var = '{'.$variable.'}';                                                                                                                                                                                                  
     694                 :         }                                                                                                                                                                                                                              
     695             360 :         return '$_scope->'. $var . '->value';                                                                                                                                                                                          
     696                 :     }                                                                                                                                                                                                                                  
     697                 :                                                                                                                                                                                                                                        
     698                 :     /**                                                                                                                                                                                                                                
     699                 :      * Check for plugins and return function name                                                                                                                                                                                      
     700                 :      *                                                                                                                                                                                                                                 
     701                 :      * @param  string $plugin_name name of plugin or function                                                                                                                                                                          
     702                 :      * @param  string $plugin_type type of plugin                                                                                                                                                                                      
     703                 :      * @return string call name of function                                                                                                                                                                                            
     704                 :      */                                                                                                                                                                                                                                
     705                 :     public function getPlugin($plugin_name, $plugin_type)                                                                                                                                                                              
     706                 :     {                                                                                                                                                                                                                                  
     707             236 :         $function = null;                                                                                                                                                                                                              
     708             236 :         if ($this->caching && ($this->nocache || $this->tag_nocache)) {                                                                                                                                                                
     709               5 :             if (isset($this->required_plugins['nocache'][$plugin_name][$plugin_type])) {                                                                                                                                               
     710               0 :                 $function = $this->required_plugins['nocache'][$plugin_name][$plugin_type]['function'];                                                                                                                                
     711               5 :             } elseif (isset($this->required_plugins['compiled'][$plugin_name][$plugin_type])) {                                                                                                                                        
     712               0 :                 $this->required_plugins['nocache'][$plugin_name][$plugin_type] = $this->required_plugins['compiled'][$plugin_name][$plugin_type];                                                                                      
     713               0 :                 $function = $this->required_plugins['nocache'][$plugin_name][$plugin_type]['function'];                                                                                                                                
     714               0 :             }                                                                                                                                                                                                                          
     715               5 :         } else {                                                                                                                                                                                                                       
     716             231 :             if (isset($this->required_plugins['compiled'][$plugin_name][$plugin_type])) {                                                                                                                                              
     717              28 :                 $function = $this->required_plugins['compiled'][$plugin_name][$plugin_type]['function'];                                                                                                                               
     718             231 :             } elseif (isset($this->required_plugins['nocache'][$plugin_name][$plugin_type])) {                                                                                                                                         
     719               0 :                 $this->required_plugins['compiled'][$plugin_name][$plugin_type] = $this->required_plugins['nocache'][$plugin_name][$plugin_type];                                                                                      
     720               0 :                 $function = $this->required_plugins['compiled'][$plugin_name][$plugin_type]['function'];                                                                                                                               
     721               0 :             }                                                                                                                                                                                                                          
     722                 :         }                                                                                                                                                                                                                              
     723             236 :         if (isset($function)) {                                                                                                                                                                                                        
     724              28 :             if ($plugin_type == 'modifier') {                                                                                                                                                                                          
     725               1 :                 $this->modifier_plugins[$plugin_name] = true;                                                                                                                                                                          
     726               1 :             }                                                                                                                                                                                                                          
     727                 :                                                                                                                                                                                                                                        
     728              28 :             return $function;                                                                                                                                                                                                          
     729                 :         }                                                                                                                                                                                                                              
     730                 :         // loop through plugin dirs and find the plugin                                                                                                                                                                                
     731             236 :         $function = 'smarty_' . $plugin_type . '_' . $plugin_name;                                                                                                                                                                     
     732             236 :         $file = $this->tpl_obj->_loadPlugin($function, false);                                                                                                                                                                         
     733                 :                                                                                                                                                                                                                                        
     734             236 :         if (is_string($file)) {                                                                                                                                                                                                        
     735             185 :             if ($this->caching && ($this->nocache || $this->tag_nocache)) {                                                                                                                                                            
     736               3 :                 $this->required_plugins['nocache'][$plugin_name][$plugin_type]['file'] = $file;                                                                                                                                        
     737               3 :                 $this->required_plugins['nocache'][$plugin_name][$plugin_type]['function'] = $function;                                                                                                                                
     738               3 :             } else {                                                                                                                                                                                                                   
     739             182 :                 $this->required_plugins['compiled'][$plugin_name][$plugin_type]['file'] = $file;                                                                                                                                       
     740             182 :                 $this->required_plugins['compiled'][$plugin_name][$plugin_type]['function'] = $function;                                                                                                                               
     741                 :             }                                                                                                                                                                                                                          
     742             185 :             if ($plugin_type == 'modifier') {                                                                                                                                                                                          
     743              43 :                 $this->modifier_plugins[$plugin_name] = true;                                                                                                                                                                          
     744              43 :             }                                                                                                                                                                                                                          
     745                 :                                                                                                                                                                                                                                        
     746             185 :             return $function;                                                                                                                                                                                                          
     747                 :         }                                                                                                                                                                                                                              
     748              75 :         if (is_callable($function)) {                                                                                                                                                                                                  
     749                 :             // plugin function is defined in the script                                                                                                                                                                                
     750               0 :             return $function;                                                                                                                                                                                                          
     751                 :         }                                                                                                                                                                                                                              
     752                 :                                                                                                                                                                                                                                        
     753              75 :         return false;                                                                                                                                                                                                                  
     754                 :     }                                                                                                                                                                                                                                  
     755                 :                                                                                                                                                                                                                                        
     756                 :     /**                                                                                                                                                                                                                                
     757                 :      * Check for plugins by default plugin handler                                                                                                                                                                                     
     758                 :      *                                                                                                                                                                                                                                 
     759                 :      * @param  string  $tag         name of tag                                                                                                                                                                                        
     760                 :      * @param  string  $plugin_type type of plugin                                                                                                                                                                                     
     761                 :      * @return boolean true if found                                                                                                                                                                                                   
     762                 :      */                                                                                                                                                                                                                                
     763                 :     public function getPluginFromDefaultHandler($tag, $plugin_type)                                                                                                                                                                    
     764                 :     {                                                                                                                                                                                                                                  
     765              10 :         $callback = null;                                                                                                                                                                                                              
     766              10 :         $script = null;                                                                                                                                                                                                                
     767              10 :         $cacheable = true;                                                                                                                                                                                                             
     768              10 :         $result = call_user_func_array(                                                                                                                                                                                                
     769              10 :             $this->tpl_obj->default_plugin_handler_func, array($tag, $plugin_type, $this->tpl_obj, &$callback, &$script, &$cacheable)                                                                                                  
     770              10 :         );                                                                                                                                                                                                                             
     771              10 :         if ($result) {                                                                                                                                                                                                                 
     772              10 :             $this->tag_nocache = $this->tag_nocache || !$cacheable;                                                                                                                                                                    
     773              10 :             if ($script !== null) {                                                                                                                                                                                                    
     774               8 :                 if (is_file($script)) {                                                                                                                                                                                                
     775               8 :                     if ($this->caching && ($this->nocache || $this->tag_nocache)) {                                                                                                                                                    
     776               4 :                         $this->required_plugins['nocache'][$tag][$plugin_type]['file'] = $script;                                                                                                                                      
     777               4 :                         $this->required_plugins['nocache'][$tag][$plugin_type]['function'] = $callback;                                                                                                                                
     778               4 :                     } else {                                                                                                                                                                                                           
     779               4 :                         $this->required_plugins['compiled'][$tag][$plugin_type]['file'] = $script;                                                                                                                                     
     780               4 :                         $this->required_plugins['compiled'][$tag][$plugin_type]['function'] = $callback;                                                                                                                               
     781                 :                     }                                                                                                                                                                                                                  
     782               8 :                     include_once $script;                                                                                                                                                                                              
     783               8 :                 } else {                                                                                                                                                                                                               
     784               0 :                     $this->trigger_template_error("Default plugin handler: Returned script file \"{$script}\" for \"{$tag}\" not found");                                                                                              
     785                 :                 }                                                                                                                                                                                                                      
     786               8 :             }                                                                                                                                                                                                                          
     787              10 :             if (!is_string($callback) && !(is_array($callback) && is_string($callback[0]) && is_string($callback[1]))) {                                                                                                               
     788               0 :                 $this->trigger_template_error("Default plugin handler: Returned callback for \"{$tag}\" must be a static function name or array of class and function name");                                                          
     789               0 :             }                                                                                                                                                                                                                          
     790              10 :             if (is_callable($callback)) {                                                                                                                                                                                              
     791              10 :                 $this->default_handler_plugins[$plugin_type][$tag] = array($callback, true, array());                                                                                                                                  
     792                 :                                                                                                                                                                                                                                        
     793              10 :                 return true;                                                                                                                                                                                                           
     794                 :             } else {                                                                                                                                                                                                                   
     795               0 :                 $this->trigger_template_error("Default plugin handler: Returned callback for \"{$tag}\" not callable");                                                                                                                
     796                 :             }                                                                                                                                                                                                                          
     797               0 :         }                                                                                                                                                                                                                              
     798                 :                                                                                                                                                                                                                                        
     799               2 :         return false;                                                                                                                                                                                                                  
     800                 :     }                                                                                                                                                                                                                                  
     801                 :                                                                                                                                                                                                                                        
     802                 :     /**                                                                                                                                                                                                                                
     803                 :      * Inject inline code for nocache template sections                                                                                                                                                                                
     804                 :      *                                                                                                                                                                                                                                 
     805                 :      * This method gets the content of each template element from the parser.                                                                                                                                                          
     806                 :      * If the content is compiled code and it should be not cached the code is injected                                                                                                                                                
     807                 :      * into the rendered output.                                                                                                                                                                                                       
     808                 :      *                                                                                                                                                                                                                                 
     809                 :      * @param  string  $tagCode code of template element                                                                                                                                                                               
     810                 :      * @param  boolean $is_code true if content is compiled code                                                                                                                                                                       
     811                 :      * @return string  content                                                                                                                                                                                                         
     812                 :      */                                                                                                                                                                                                                                
     813                 :     public function nocacheCode($tagCode, $is_code)                                                                                                                                                                                    
     814                 :     {                                                                                                                                                                                                                                  
     815                 :         // If the template is not evaluated and we have a nocache section and or a nocache tag                                                                                                                                         
     816             768 :         if ($is_code && (!empty($this->prefix_code) || !empty($this->postfix_code) || !empty($tagCode->buffer))) {                                                                                                                     
     817                 :                                                                                                                                                                                                                                        
     818                 :             // generate replacement code                                                                                                                                                                                               
     819             767 :             $make_nocache_code = $this->nocache || $this->tag_nocache || $this->forceNocache == 2;                                                                                                                                     
     820             767 :             if ((!($this->source->recompiled) || $this->forceNocache) && $this->caching && !$this->suppressNocacheProcessing &&                                                                                                        
     821              25 :                 ($make_nocache_code || $this->nocache_nolog)                                                                                                                                                                           
     822             767 :             ) {                                                                                                                                                                                                                        
     823              21 :                 if ($make_nocache_code) {                                                                                                                                                                                              
     824              21 :                     $this->has_nocache_code = true;                                                                                                                                                                                    
     825              21 :                 }                                                                                                                                                                                                                      
     826              21 :                 $code = new Smarty_Compiler_Code();                                                                                                                                                                                    
     827              21 :                 $code->iniTagCode($this);                                                                                                                                                                                              
     828                 :                                                                                                                                                                                                                                        
     829              21 :                 foreach ($this->prefix_code as $prefix_code) {                                                                                                                                                                         
     830               0 :                     $code->mergeCode($prefix_code);                                                                                                                                                                                    
     831              21 :                 }                                                                                                                                                                                                                      
     832              21 :                 $code->mergeCode($tagCode);                                                                                                                                                                                            
     833              21 :                  $this->template_code->php("echo \"/*%%SmartyNocache%%*/" . str_replace(array("^#^", "^##^"), array('"', '$'), addcslashes($code->buffer, "\0\t\"\$\\")) . "/*/%%SmartyNocache%%*/\";\n");                             
     834              21 :                 foreach ($this->postfix_code as $postfix_code) {                                                                                                                                                                       
     835               0 :                     $this->template_code->mergeCode($postfix_code);                                                                                                                                                                    
     836              21 :                 }                                                                                                                                                                                                                      
     837                 :                 // make sure we include modifier plugins for nocache code                                                                                                                                                              
     838              21 :                 foreach ($this->modifier_plugins as $plugin_name => $dummy) {                                                                                                                                                          
     839               0 :                     if (isset($this->required_plugins['compiled'][$plugin_name]['modifier'])) {                                                                                                                                        
     840               0 :                         $this->required_plugins['nocache'][$plugin_name]['modifier'] = $this->required_plugins['compiled'][$plugin_name]['modifier'];                                                                                  
     841               0 :                     }                                                                                                                                                                                                                  
     842              21 :                 }                                                                                                                                                                                                                      
     843              21 :             } else {                                                                                                                                                                                                                   
     844             758 :                 foreach ($this->prefix_code as $prefix_code) {                                                                                                                                                                         
     845              12 :                     $this->template_code->mergeCode($prefix_code);                                                                                                                                                                     
     846             754 :                 }                                                                                                                                                                                                                      
     847                 :                                                                                                                                                                                                                                        
     848             754 :                 $this->template_code->mergeCode($tagCode);                                                                                                                                                                             
     849                 :                                                                                                                                                                                                                                        
     850             754 :                 foreach ($this->postfix_code as $postfix_code) {                                                                                                                                                                       
     851               0 :                     $this->template_code->mergeCode($postfix_code);                                                                                                                                                                    
     852             754 :                 }                                                                                                                                                                                                                      
     853                 :             }                                                                                                                                                                                                                          
     854             763 :         } else {                                                                                                                                                                                                                       
     855               1 :             $this->template_code->mergeCode($tagCode);                                                                                                                                                                                 
     856                 :         }                                                                                                                                                                                                                              
     857             764 :         $this->prefix_code = array();                                                                                                                                                                                                  
     858             764 :         $this->postfix_code = array();                                                                                                                                                                                                 
     859             764 :         $this->modifier_plugins = array();                                                                                                                                                                                             
     860             764 :         $this->suppressNocacheProcessing = false;                                                                                                                                                                                      
     861             764 :         $this->tag_nocache = false;                                                                                                                                                                                                    
     862             764 :         $this->nocache_nolog = false;                                                                                                                                                                                                  
     863                 :                                                                                                                                                                                                                                        
     864             764 :         return;                                                                                                                                                                                                                        
     865                 :     }                                                                                                                                                                                                                                  
     866                 :                                                                                                                                                                                                                                        
     867                 :     /**                                                                                                                                                                                                                                
     868                 :      * display compiler error messages without dying                                                                                                                                                                                   
     869                 :      *                                                                                                                                                                                                                                 
     870                 :      * If parameter $args is empty it is a parser detected syntax error.                                                                                                                                                               
     871                 :      * In this case the parser is called to obtain information about expected tokens.                                                                                                                                                  
     872                 :      *                                                                                                                                                                                                                                 
     873                 :      * If parameter $msg contains a string this is used as error message                                                                                                                                                               
     874                 :      *                                                                                                                                                                                                                                 
     875                 :      * @param  string                    $msg  individual error message or null                                                                                                                                                        
     876                 :      * @param  string                    $line line-number                                                                                                                                                                             
     877                 :      * @throws Smarty_Exception_Compiler when an unexpected token is found                                                                                                                                                             
     878                 :      */                                                                                                                                                                                                                                
     879                 :     public function trigger_template_error($msg = null, $line = null)                                                                                                                                                                  
     880                 :     {                                                                                                                                                                                                                                  
     881                 :         // get template source line which has error                                                                                                                                                                                    
     882              45 :         if (!isset($line)) {                                                                                                                                                                                                           
     883               5 :             $line = $this->lex->line;                                                                                                                                                                                                  
     884               5 :         } else {                                                                                                                                                                                                                       
     885                 :             /** @var $this TYPE_NAME */                                                                                                                                                                                                
     886              40 :             $line = $line - $this->line_offset;                                                                                                                                                                                        
     887                 :         }                                                                                                                                                                                                                              
     888              45 :         preg_match_all("/\n/", $this->lex->data, $match, PREG_OFFSET_CAPTURE);                                                                                                                                                         
     889              45 :         $start_line = max(1, $line - 2);                                                                                                                                                                                               
     890              45 :         $end_line = min($line + 2, count($match[0]) + 1);                                                                                                                                                                              
     891              45 :         $source = "<br>";                                                                                                                                                                                                              
     892              45 :         for ($i = $start_line; $i <= $end_line; $i++) {                                                                                                                                                                                
     893              45 :             $from = 0;                                                                                                                                                                                                                 
     894              45 :             $to = 99999999;                                                                                                                                                                                                            
     895              45 :             if (isset($match[0][$i - 2])) {                                                                                                                                                                                            
     896               5 :                 $from = $match[0][$i - 2][1];                                                                                                                                                                                          
     897               5 :             }                                                                                                                                                                                                                          
     898              45 :             if (isset($match[0][$i - 1])) {                                                                                                                                                                                            
     899               5 :                 $to = $match[0][$i - 1][1] - $from;                                                                                                                                                                                    
     900               5 :             }                                                                                                                                                                                                                          
     901              45 :             $substr = substr($this->lex->data, $from, $to);                                                                                                                                                                            
     902              45 :             $source .= sprintf('%4d : ', $i + $this->line_offset) . htmlspecialchars(trim(preg_replace('![\t\r\n]+!', ' ', $substr))) . "<br>";                                                                                        
     903              45 :         }                                                                                                                                                                                                                              
     904              45 :         $error_text = "<b>Syntax Error</b> in template <b>'{$this->source->filepath}'</b>  on line " . ($line + $this->line_offset) . "<br>{$source}";                                                                                 
     905              45 :         if (isset($msg)) {                                                                                                                                                                                                             
     906                 :             // individual error message                                                                                                                                                                                                
     907              45 :             $error_text .= "<br><b>{$msg}</b><br>";                                                                                                                                                                                    
     908              45 :         } else {                                                                                                                                                                                                                       
     909                 :             // expected token from parser                                                                                                                                                                                              
     910               0 :             $error_text .= "<br> Unexpected '<b>{$this->lex->value}</b>'";                                                                                                                                                             
     911               0 :             if (count($this->parser->yy_get_expected_tokens($this->parser->yymajor)) <= 4) {                                                                                                                                           
     912               0 :                 foreach ($this->parser->yy_get_expected_tokens($this->parser->yymajor) as $token) {                                                                                                                                    
     913               0 :                     $exp_token = $this->parser->yyTokenName[$token];                                                                                                                                                                   
     914               0 :                     if (isset($this->lex->smarty_token_names[$exp_token])) {                                                                                                                                                           
     915                 :                         // token type from lexer                                                                                                                                                                                       
     916               0 :                         $expect[] = "'<b>{$this->lex->smarty_token_names[$exp_token]}</b>'";                                                                                                                                           
     917               0 :                     } else {                                                                                                                                                                                                           
     918                 :                         // otherwise internal token name                                                                                                                                                                               
     919               0 :                         $expect[] = $this->parser->yyTokenName[$token];                                                                                                                                                                
     920                 :                     }                                                                                                                                                                                                                  
     921               0 :                 }                                                                                                                                                                                                                      
     922               0 :                 $error_text .= ', expected one of: ' . implode(' , ', $expect) . '<br>';                                                                                                                                               
     923               0 :             }                                                                                                                                                                                                                          
     924                 :         }                                                                                                                                                                                                                              
     925              45 :         throw new Smarty_Exception_Compiler($error_text);                                                                                                                                                                              
     926                 :     }                                                                                                                                                                                                                                  
     927                 :                                                                                                                                                                                                                                        
     928                 :     /**                                                                                                                                                                                                                                
     929                 :      * Create Smarty content class for compiled template files                                                                                                                                                                         
     930                 :      *                                                                                                                                                                                                                                 
     931                 :      * @param  Smarty $tpl_obj    template object                                                                                                                                                                                      
     932                 :      * @param  bool   $noinstance flag if code for creating instance shall be suppressed                                                                                                                                               
     933                 :      * @return string                                                                                                                                                                                                                  
     934                 :      */                                                                                                                                                                                                                                
     935                 :     public function _createSmartyContentClass(Smarty $tpl_obj, $noinstance = false)                                                                                                                                                    
     936                 :     {                                                                                                                                                                                                                                  
     937             836 :         $template_code = new Smarty_Compiler_Code();                                                                                                                                                                                   
     938             836 :         $template_code->php("<?php /* Smarty version " . Smarty::SMARTY_VERSION . ", created on " . strftime("%Y-%m-%d %H:%M:%S") . " compiled from \"{$this->source->filepath}\" */")->newline();                                     
     939             836 :         $template_code->php("if (!class_exists('{$this->content_class}',false)) {")->newline()->indent();                                                                                                                              
     940             836 :         $template_code->php("class {$this->content_class} extends Smarty_Template_" . ($this->isInheritance ? 'Inheritance' : 'Class') . " {")->newline()->indent();                                                                   
     941             836 :         $template_code->php("public \$version = '" . Smarty::SMARTY_VERSION . "';")->newline();                                                                                                                                        
     942             836 :         $template_code->php("public \$has_nocache_code = " . ($this->has_nocache_code ? 'true' : 'false') . ";")->newline();                                                                                                           
     943             836 :         if ($this->isInheritanceChild) {                                                                                                                                                                                               
     944              21 :             $template_code->php("public \$is_inheritance_child = true;")->newline();                                                                                                                                                   
     945              21 :         }                                                                                                                                                                                                                              
     946             836 :         if (!empty($tpl_obj->cached_subtemplates)) {                                                                                                                                                                                   
     947               0 :             $template_code->php("public \$cached_subtemplates = ")->repr($tpl_obj->cached_subtemplates, false)->raw(';')->newline();                                                                                                   
     948               0 :         }                                                                                                                                                                                                                              
     949             836 :         if (!$noinstance) {                                                                                                                                                                                                            
     950             836 :             $template_code->php("public \$file_dependency = ")->repr($this->file_dependency, false)->raw(';')->newline();                                                                                                              
     951             836 :         }                                                                                                                                                                                                                              
     952             836 :         if (!empty($this->required_plugins['compiled'])) {                                                                                                                                                                             
     953             202 :             $plugins = array();                                                                                                                                                                                                        
     954             202 :             foreach ($this->required_plugins['compiled'] as $tmp) {                                                                                                                                                                    
     955             202 :                 foreach ($tmp as $data) {                                                                                                                                                                                              
     956             202 :                     $plugins[$data['file']] = $data['function'];                                                                                                                                                                       
     957             202 :                 }                                                                                                                                                                                                                      
     958             202 :             }                                                                                                                                                                                                                          
     959             202 :             $template_code->php("public \$required_plugins = ")->repr($plugins, false)->raw(';')->newline();                                                                                                                           
     960             202 :         }                                                                                                                                                                                                                              
     961                 :                                                                                                                                                                                                                                        
     962             836 :         if (!empty($this->required_plugins['nocache'])) {                                                                                                                                                                              
     963               7 :             $plugins = array();                                                                                                                                                                                                        
     964               7 :             foreach ($this->required_plugins['nocache'] as $tmp) {                                                                                                                                                                     
     965               7 :                 foreach ($tmp as $data) {                                                                                                                                                                                              
     966               7 :                     $plugins[$data['file']] = $data['function'];                                                                                                                                                                       
     967               7 :                 }                                                                                                                                                                                                                      
     968               7 :             }                                                                                                                                                                                                                          
     969               7 :             $template_code->php("public \$required_plugins_nocache = ")->repr($plugins, false)->raw(';')->newline();                                                                                                                   
     970               7 :         }                                                                                                                                                                                                                              
     971                 :                                                                                                                                                                                                                                        
     972             836 :         if (!empty($this->template_functions)) {                                                                                                                                                                                       
     973               8 :             $template_code->php("public \$template_functions = ")->repr($this->template_functions, false)->raw(';')->newline();                                                                                                        
     974               8 :         }                                                                                                                                                                                                                              
     975             836 :         if (!empty($this->inheritance_blocks)) {                                                                                                                                                                                       
     976              25 :             $template_code->php("public \$inheritance_blocks = ")->repr($this->inheritance_blocks, false)->raw(';')->newline();                                                                                                        
     977              25 :         }                                                                                                                                                                                                                              
     978             836 :         if (!empty($this->called_nocache_template_functions)) {                                                                                                                                                                        
     979               1 :             $template_code->php("public \$called_nocache_template_functions = ")->repr($this->called_nocache_template_functions, false)->raw(';')->newline();                                                                          
     980               1 :         }                                                                                                                                                                                                                              
     981             836 :         $template_code->newline()->newline()->php("function _renderTemplate (\$_smarty_tpl, \$_scope) {")->newline()->indent();                                                                                                        
     982             836 :         $template_code->php("ob_start();")->newline();                                                                                                                                                                                 
     983             836 :         $template_code->mergeCode($this->template_code);                                                                                                                                                                               
     984             836 :         if (!empty($this->compiled_footer_code)) {                                                                                                                                                                                     
     985              21 :             $template_code->buffer .= implode('', $this->compiled_footer_code);                                                                                                                                                        
     986              21 :         }                                                                                                                                                                                                                              
     987             836 :         $template_code->php("return ob_get_clean();")->newline();                                                                                                                                                                      
     988             836 :         $template_code->outdent()->php('}')->newline()->newline();                                                                                                                                                                     
     989             836 :         foreach ($this->template_functions_code as $code) {                                                                                                                                                                            
     990               8 :             $template_code->mergeCode($code)->newline();                                                                                                                                                                               
     991             836 :         }                                                                                                                                                                                                                              
     992             836 :         foreach ($this->inheritance_blocks_code as $code) {                                                                                                                                                                            
     993              25 :             $template_code->mergeCode($code)->newline();                                                                                                                                                                               
     994             813 :         }                                                                                                                                                                                                                              
     995             813 :         $template_code->php("function _getSourceInfo () {")->newline()->indent();                                                                                                                                                      
     996             813 :         $template_code->php("return ")->repr($template_code->traceback)->raw(";")->newline();                                                                                                                                          
     997             813 :         $template_code->outdent()->php('}')->newline();                                                                                                                                                                                
     998                 :                                                                                                                                                                                                                                        
     999             813 :         $template_code->outdent()->php('}')->newline()->outdent()->php('}')->newline();                                                                                                                                                
    1000             813 :         if (!$noinstance) {                                                                                                                                                                                                            
    1001             813 :             foreach (self::$merged_inline_content_classes as $key => $inlinetpl_obj) {                                                                                                                                                 
    1002               0 :                 $template_code->newline()->raw($inlinetpl_obj['code']);                                                                                                                                                                
    1003               0 :                 unset(self::$merged_inline_content_classes[$key], $inlinetpl_obj);                                                                                                                                                     
    1004             813 :             }                                                                                                                                                                                                                          
    1005             813 :         }                                                                                                                                                                                                                              
    1006             813 :         if (!$noinstance) {                                                                                                                                                                                                            
    1007             813 :             $template_code->php("\$this->smarty_content = new {$this->content_class}(\$tpl_obj, \$this);")->newline()->newline();                                                                                                      
    1008             813 :         }                                                                                                                                                                                                                              
    1009                 :                                                                                                                                                                                                                                        
    1010             813 :         return $template_code;                                                                                                                                                                                                         
    1011                 :     }                                                                                                                                                                                                                                  
    1012                 :                                                                                                                                                                                                                                        
    1013                 : }                                                                                                                                                                                                                                      

Generated by PHP_CodeCoverage 1.0.5 using PHP 5.4.3 and PHPUnit 3.5.15 at Tue Jul 9 0:03:17 UTC 2013.